import { computed, reactive, ref, watch } from 'vue';
import { useRoute } from 'vue-router';
import { defineStore } from 'pinia';
import { useLoading } from '@sa/hooks';
import { SetupStoreId } from '@/enum';
import { useRouterPush } from '@/hooks/common/router';
import { fetchGetUserInfo, fetchGetUserList, fetchLogin } from '@/service/api';
import { localStg } from '@/utils/storage';
import { $t } from '@/locales';
import type { Api } from '@/typings/api';
import { useRouteStore } from '../route';
import { useTabStore } from '../tab';
import { clearAuthStorage, getToken } from './shared';
export const useAuthStore = defineStore(SetupStoreId.Auth, () => {
  const route = useRoute();
  const routeStore = useRouteStore();
  const tabStore = useTabStore();
  const { toLogin, redirectFromLogin } = useRouterPush(false);
  const { loading: loginLoading, startLoading, endLoading } = useLoading();

  const token = ref(getToken());

  const userInfo: Api.Auth.UserInfo = reactive({
    userId: '',
    userName: '',
    roles: [],
    buttons: [],
  });

  /** is super role in static route */
  const isStaticSuper = computed(() => {
    const { VITE_AUTH_ROUTE_MODE, VITE_STATIC_SUPER_ROLE } = import.meta.env;

    return (
      VITE_AUTH_ROUTE_MODE === 'static' &&
      userInfo.roles.includes(VITE_STATIC_SUPER_ROLE)
    );
  });

  /** Is login */

  let isLogin = computed(() => {
    return Boolean(token.value);
  });

  /** Reset auth store */
  async function resetStore() {
    const authStore = useAuthStore();

    clearAuthStorage();

    authStore.$reset();

    if (!route.meta.constant) {
      await toLogin();
    }

    tabStore.cacheTabs();
    routeStore.resetStore();
  }

  /**
   * Login
   *
   * @param userName User name
   * @param password Password
   * @param tcr tcr
   * @param [redirect=true] Whether to redirect after login. Default is `true`
   */
  async function login(userName: string, password: string, redirect = true) {
    startLoading();

    const { data: loginToken, error }: any = await fetchLogin(
      userName,
      password
    );

    if (loginToken?.data.user?.role !== 'admin' && loginToken) {
      window.$notification?.warning({
        title: $t('common.warning'),
        content: $t('request.logoutPowerMsg'),
        duration: 4500,
      });
      endLoading();
      return;
    }
    token.value = loginToken.data.token;
    isLogin = computed(() => {
      return Boolean(token.value);
    });

    if (!error) {
      localStg.set('user', loginToken?.data.user);
      localStg.set('token', token.value);
      // const pass = await loginByToken(loginToken);
      const pass = true;

      if (pass) {
        await routeStore.initAuthRoute();

        if (redirect) {
          await redirectFromLogin();
        }

        if (routeStore.isInitAuthRoute) {
          window.$notification?.success({
            title: $t('page.login.common.loginSuccess'),
            content: $t('page.login.common.welcomeBack', { userName }),
            duration: 4500,
          });
        }
      }
    } else {
      resetStore();
    }

    endLoading();
  }

  async function loginByToken(loginToken: any) {
    // 1. stored in the localStorage, the later requests need it in headers
    localStg.set('token', loginToken.token);
    const { data }: any = await fetchGetUserList({ id: loginToken?.user?.id });
    delete data.data[0].options;
    Object.assign(userInfo, data.data[0]);
    localStg.set('user', data.data[0]);
    // localStg.set('user', loginToken.user);
    localStg.set('refreshToken', loginToken.refreshToken);

    // 2. get user info
    // const pass = await getUserInfo();

    // if (pass) {
    //   token.value = loginToken.token;

    //   return true;
    // }

    // return false;
    return true;
  }

  // async function getUserInfo() {
  //   const { data: info, error } = await fetchGetUserInfo();

  //   if (!error) {
  //     // update store
  //     Object.assign(userInfo, info);

  //     return true;
  //   }

  //   return false;
  // }

  // async function initUserInfo() {
  //   const hasToken = getToken();

  //   if (hasToken) {
  //     const pass = await getUserInfo();

  //     if (!pass) {
  //       resetStore();
  //     }
  //   }
  // }

  return {
    token,
    userInfo,
    isStaticSuper,
    isLogin,
    loginLoading,
    resetStore,
    login,
    // initUserInfo,
  };
});
